home *** CD-ROM | disk | FTP | other *** search
/ Aminet 49 / Aminet 49 (2002)(GTI - Schatztruhe)[!][Jun 2002].iso / Aminet / util / libs / muitoolkit-src.lha / muitoolkit-2.1_src / mt_funcs.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-09-16  |  24.3 KB  |  1,002 lines
  1.  
  2. /*
  3. $Id: mt_funcs.c,v 1.9 2001/01/14 14:50:03 carlos Exp $.
  4. */
  5.  
  6. #include "mt_includes.h"
  7. #include "mt_private.h"
  8.  
  9. // v1
  10.  
  11.  
  12. //#define HighliteLabel(num)         TextObject, MUIA_Weight, 1, MUIA_Text_Contents, GS(num), MUIA_Text_PreParse, "\0333", End
  13. //#define HighliteLabelKey(num, key) TextObject, MUIA_Weight, 1, MUIA_Text_Contents, GS(num), MUIA_Text_PreParse, "\0333", MUIA_Text_HiChar, (char)key[0], End
  14. //#define LabelKey(num, key)         TextObject, MUIA_Weight, 1, MUIA_Text_PreParse, "\033r", MUIA_Text_Contents, GS(num), MUIA_Text_HiChar, (char)key[0], End
  15.  
  16. /// mt_Get
  17. ULONG SAVEDS ASM mt_Get( REG(a0) Object *obj, REG(d0) ULONG attr )
  18. {
  19. ULONG tmp;
  20.  
  21.     get( obj, attr, &tmp );
  22.     return( tmp );
  23. }
  24. //|
  25.  
  26. /// mt_ParseHotkey
  27.  
  28. char SAVEDS ASM mt_ParseHotkey( REG(a0) char *string )
  29. {
  30. char *Button;
  31. char Key = '\0';
  32.  
  33.     if(string)
  34.        {
  35.        Button = strchr(string, '_');
  36.  
  37.        if(Button)
  38.          Key = ToLower(Button[1]);
  39.  
  40.        }
  41.  
  42.     return(Key);
  43. }
  44. //|
  45.  
  46. /// mt_Label
  47. Object * SAVEDS ASM mt_Label( REG(a0) char *str )
  48. {
  49. // Etykieta
  50.  
  51.       return(MUI_MakeObject(MUIO_Label    ,str, MUIO_Label_DoubleFrame));
  52. }
  53. //|
  54. /// mt_PopButton
  55.  
  56. Object * SAVEDS ASM mt_PopButton( REG(d0) int img, REG(a0) char *key )
  57. {
  58. // PopButton z szortkatem
  59.  
  60.        Object *obj = MUI_MakeObject(MUIO_PopButton, img);
  61.  
  62.        if(obj)
  63.            {
  64.            set(obj, MUIA_CycleChain, TRUE);
  65.            set(obj, MUIA_ControlChar, mt_ParseHotkey(key));
  66.            }
  67.        return(obj);
  68. }
  69. //|
  70. /// mt_Checkmark
  71.  
  72. Object * SAVEDS ASM mt_Checkmark( REG(a0) char *str,
  73.                                   REG(d0) ULONG val,
  74.                                   REG(a1) char *help )
  75. {
  76. // Czekmark z szortkatem
  77.  
  78.         Object *obj = MUI_MakeObject(MUIO_Checkmark, str);
  79.         if(obj)
  80.            {
  81.            set(obj, MUIA_Selected, val );
  82.            set(obj, MUIA_CycleChain, TRUE);
  83.            set(obj, MUIA_ShortHelp, help );
  84.            }
  85.         return(obj);
  86. }
  87. //|
  88.  
  89. /// mt_Cycle
  90.  
  91. Object * SAVEDS ASM mt_Cycle( REG(a0) char **array,
  92.                               REG(a1) char *str,
  93.                               REG(d0) ULONG val,
  94.                               REG(a2) char *help )
  95. {
  96. // Sajkl z szortkatem
  97.  
  98.         Object *obj = MUI_MakeObject(MUIO_Cycle , str, array);
  99.         if(obj)
  100.            {
  101.            set(obj, MUIA_Cycle_Active, val );
  102.            set(obj, MUIA_CycleChain, TRUE);
  103.            set(obj, MUIA_ShortHelp, help );
  104.            }
  105.  
  106.         return(obj);
  107. }
  108. //|
  109. /// mt_CycleWeight
  110.  
  111. Object * SAVEDS ASM mt_CycleWeight( REG(a0) char **array,
  112.                                     REG(a1) char *str,
  113.                                     REG(d0) ULONG value,
  114.                                     REG(d1) long weight,
  115.                                     REG(a2) char *help )
  116. {
  117. // Sajkl z szortkatem
  118.  
  119.         Object *obj = mt_Cycle(array, str, value, help);
  120.         if(obj)
  121.            {
  122.            set(obj, MUIA_Weight, weight);
  123.            }
  124.  
  125.         return(obj);
  126. }
  127. //|
  128.  
  129. /// mt_Slider
  130.  
  131. Object * SAVEDS ASM mt_Slider( REG(d0) int min,
  132.                                REG(d1) int max,
  133.                                REG(d2) int level,
  134.                                REG(a0) char *str,
  135.                                REG(a1) char *help )
  136. {
  137. Object *obj = SliderObject, SliderFrame, SliderBack,
  138.                             MUIA_ControlChar, mt_ParseHotkey(str),
  139.                             MUIA_Slider_Min, min,
  140.                             MUIA_Slider_Max, max,
  141.                             MUIA_CycleChain, TRUE,
  142.                             MUIA_Slider_Level, level,
  143.                             MUIA_ShortHelp, help,
  144.                             End;
  145.  
  146.         return(obj);
  147. }
  148. //|
  149. /// mt_SliderFmt
  150.  
  151. Object * SAVEDS ASM mt_SliderFmt( REG(d0) int min,
  152.                                   REG(d1) int max,
  153.                                   REG(d2) int level,
  154.                                   REG(a0) char *str,
  155.                                   REG(a1) char *fmt,
  156.                                   REG(a2) char *help )
  157. {
  158. APTR obj = mt_Slider( min, max, level, str, help );
  159.  
  160.     if( obj )
  161.        {
  162.        set( obj, MUIA_Numeric_Format, fmt);
  163.        }
  164.  
  165.     return( obj );
  166. }
  167.  
  168. //|
  169.  
  170. /// mt_String
  171.  
  172. Object * SAVEDS ASM mt_String( REG(a0) char *str,
  173.                                REG(d0) int maxlen,
  174.                                REG(a1) char *label,
  175.                                REG(a2) char *help )
  176. {
  177.  
  178. Object *obj;
  179.  
  180.     obj = StringObject, StringFrame,
  181.                             MUIA_ControlChar, mt_ParseHotkey( label ),
  182.                             MUIA_String_MaxLen, maxlen,
  183.                             MUIA_CycleChain, TRUE,
  184.                             MUIA_String_AdvanceOnCR, TRUE,
  185.                             End;
  186.  
  187.    if( str )
  188.      set( obj, MUIA_String_Contents, str );
  189.  
  190.    if( help )
  191.      set( obj, MUIA_ShortHelp, help );
  192.  
  193.    return(obj);
  194. }
  195. //|
  196. /// mt_StringSecret
  197.  
  198. Object * SAVEDS ASM mt_StringSecret( REG(a0) char *text,
  199.                                      REG(d0) int maxlen,
  200.                                      REG(a1) char *label,
  201.                                      REG(a2) char *help )
  202. {
  203.  
  204.     Object *obj = mt_String(text, maxlen, label, help );
  205.  
  206.     if( obj )
  207.        set(obj, MUIA_String_Secret, TRUE);
  208.  
  209.     return(obj);
  210.  
  211. }
  212. //|
  213. /// mt_StringAccept
  214. Object * SAVEDS ASM mt_StringAccept( REG(a0) char *text,
  215.                                      REG(d0) int maxlen,
  216.                                      REG(a1) char *label,
  217.                                      REG(a2) char *accept,
  218.                                      REG(a3) char *help
  219.                                      )
  220. {
  221.     Object *obj = mt_String(text, maxlen, label, help );
  222.  
  223.     if( obj )
  224.        set( obj, MUIA_String_Accept, accept );
  225.  
  226.     return(obj);
  227.  
  228. }
  229. //|
  230. /// mt_StringReject
  231. Object * SAVEDS ASM mt_StringReject( REG(a0) char *text,
  232.                                      REG(d0) int maxlen,
  233.                                      REG(a1) char *label,
  234.                                      REG(a2) char *reject,
  235.                                      REG(a3) char *help )
  236. {
  237.  
  238.     Object *obj = mt_String(text, maxlen, label, help );
  239.  
  240.     if( obj )
  241.        set( obj, MUIA_String_Reject, reject );
  242.  
  243.     return(obj);
  244.  
  245. }
  246. //|
  247.  
  248. /// mt_Button
  249.  
  250. Object * SAVEDS ASM mt_Button( REG(a0) char *str, REG(a1) char *help )
  251. {
  252. // buton textowy
  253.  
  254.     Object *obj = MUI_MakeObject( MUIO_Button, str );
  255.  
  256.     if(obj)
  257.        {
  258.        set( obj, MUIA_CycleChain, TRUE );
  259.        if( help )
  260.           set( obj, MUIA_ShortHelp , help );
  261.        }
  262.  
  263.     return(obj);
  264. }
  265. //|
  266. /// mt_ButtonWeight
  267.  
  268. Object * SAVEDS ASM mt_ButtonWeight( REG(a0) char *str,
  269.                                      REG(d0) int weight,
  270.                                      REG(a1) char *help )
  271. {
  272. // buton textowy z podanâ wagâ
  273.  
  274.         Object *obj = mt_Button( str, help );
  275.  
  276.         if(obj)
  277.           {
  278.           set(obj, MUIA_Weight    , weight);
  279.           }
  280.         return(obj);
  281. }
  282. //|
  283. /// mt_ButtonToggle
  284.  
  285. Object * SAVEDS ASM mt_ButtonToggle( REG(a0) char *str,
  286.                                      REG(a1) char *help )
  287. {
  288. // buton textowy typu toggle
  289.  
  290.     Object *obj = mt_Button( str, help );
  291.  
  292.     if( obj )
  293.        {
  294.        set(obj, MUIA_InputMode, MUIV_InputMode_Toggle);
  295.        }
  296.  
  297.  
  298.     return(obj);
  299. }
  300. //|
  301.  
  302. /// mt_WinOpen
  303.  
  304. ULONG SAVEDS ASM mt_WinOpen( REG(a0) Object *win )
  305. {
  306.  
  307.     set( win, MUIA_Window_Open, TRUE );
  308.     return( mt_Get( win, MUIA_Window_Open ) );
  309.  
  310. }
  311. //|
  312. /// mt_WinAttach
  313.  
  314. ULONG SAVEDS ASM mt_WinAttach( REG(a0) Object *app, REG(a1) Object *win )
  315. {
  316.  
  317.     if( app && win )
  318.                 {
  319.         DoMethod(app, OM_ADDMEMBER, win);
  320.         return( TRUE );
  321.                 }
  322.         return( FALSE );
  323.  
  324. }
  325. //|
  326. /// mt_WinDetach
  327.  
  328. void SAVEDS ASM mt_WinDetach( REG(a0) Object *app, REG(a1) Object *win )
  329. {
  330.  
  331.     if( win && app )
  332.        {
  333.        DoMethod( app, OM_REMMEMBER, win );
  334.        MUI_DisposeObject( win );
  335.        }
  336.  
  337. }
  338. //|
  339.  
  340. /// mt_Text
  341.  
  342. Object * SAVEDS ASM mt_Text( REG(a0) char *text, REG(a1) char *preparse )
  343. {
  344.  
  345.     Object *obj = TextObject, TextFrame, TextBack,
  346.                   MUIA_Text_Contents, text,
  347.                   End;
  348.  
  349.  
  350.     if( preparse && obj )
  351.        set( obj, MUIA_Text_PreParse, preparse );
  352.  
  353.  
  354.  
  355.     return( obj );
  356. }
  357.  
  358. //|
  359.  
  360. /// mt_Radio
  361.  
  362. Object * SAVEDS ASM mt_Radio( REG(a0) char *array, REG(a1) char *label, REG(a2) char *help )
  363. {
  364.  
  365.     return( RadioObject,
  366.                 MUIA_Radio_Entries, array,
  367.                 MUIA_ControlChar, mt_ParseHotkey( label ),
  368.                 MUIA_CycleChain, TRUE,
  369.                 MUIA_ShortHelp, help,
  370.                 End
  371.            );
  372.  
  373. }
  374.  
  375. //|
  376. /// mt_Check
  377.  
  378. Object * SAVEDS ASM mt_Check( REG(a0) char *label,
  379.                               REG(d0) ULONG aligment,
  380.                               REG(d1) ULONG state,
  381.                               REG(a1) char *help )
  382.  
  383. {
  384. Object *obj;
  385.  
  386.     if( aligment == mt_Check_AlignRight )
  387.        {
  388.        obj = HGroup,
  389.                    MUIA_ShortHelp, help,
  390.  
  391.                    Child, HVSpace,
  392.                    Child, mt_Label( label ),
  393.                    Child, ImageObject,
  394.                                ImageButtonFrame,
  395.                                MUIA_InputMode     , MUIV_InputMode_Toggle,
  396.                                MUIA_Image_Spec    , MUII_CheckMark,
  397.                                MUIA_Image_FreeVert, TRUE,
  398.                                MUIA_Selected      , state,
  399.                                MUIA_Background    , MUII_ButtonBack,
  400.                                MUIA_ShowSelState  , FALSE,
  401.                                MUIA_ControlChar   , mt_ParseHotkey( label ),
  402.                                MUIA_CycleChain    , TRUE,
  403.                                End,
  404.                    End;
  405.        }
  406.     else
  407.        {
  408.        obj = HGroup,
  409.                    MUIA_ShortHelp, help,
  410.  
  411.                    Child, ImageObject,
  412.                                ImageButtonFrame,
  413.                                MUIA_InputMode     , MUIV_InputMode_Toggle,
  414.                                MUIA_Image_Spec    , MUII_CheckMark,
  415.                                MUIA_Image_FreeVert, TRUE,
  416.                                MUIA_Selected      , state,
  417.                                MUIA_Background    , MUII_ButtonBack,
  418.                                MUIA_ShowSelState  , FALSE,
  419.                                MUIA_ControlChar   , mt_ParseHotkey( label ),
  420.                                End,
  421.                    Child, mt_Label( label ),
  422.                    Child, HVSpace,
  423.                    End;
  424.        }
  425.  
  426.  
  427.     return( obj );
  428. }
  429.  
  430. //|
  431.  
  432. /// mt_GetStringA
  433.  
  434. /*
  435. ** Requester dot. wartoôci numerycznych
  436. ** Zwraca BOOL w zaleûnoôci czy uûytkownik
  437. ** wybraî OK czy nie. Wynik umieszczany
  438. ** jest w odpowiednim polu struktury StringRequest
  439. ** w zaleûnoôci od typu reqestera
  440. */
  441.  
  442.  
  443. ULONG SAVEDS ASM mt_GetStringA( REG(a0) Object *app,
  444.                                 REG(a1) char   *buffer,
  445.                                 REG(d0) ULONG   buf_len,
  446.                                 REG(a2) struct TagItem *tagitem)
  447.  
  448. {
  449. Object *Window      = NULL,     /* STRING REQUESTER */
  450.         *GR_Group,
  451.         *ST_String,
  452.         *BT_Ok,
  453.         *BT_Cancel;
  454.  
  455. #define MSG_STRREQ_WINTITLE "String request"
  456. #define MSG_STRREQ_TITLE    "Enter string"
  457. #define MSG_STRREQ_OK       "_Ok"
  458. #define MSG_STRREQ_CANCEL   "_Cancel"
  459.  
  460. char *WindowTitle = MSG_STRREQ_WINTITLE;
  461. char *GroupTitle  = MSG_STRREQ_TITLE;
  462. char *Contents    = NULL;
  463. char *Ok          = MSG_STRREQ_OK;
  464. char *Cancel      = MSG_STRREQ_CANCEL;
  465. char *Info        = FALSE;
  466. char *StringHelp  = NULL;
  467.  
  468. ULONG Secret      = FALSE;
  469. ULONG NoEmpty     = FALSE;
  470.  
  471. struct TagItem *tags, *tag;
  472.  
  473. char  result  = FALSE;
  474.  
  475.  
  476.     if( !app )
  477.        return( FALSE );
  478.  
  479.  
  480.     for(tags=tagitem; tag = NextTagItem( &tags ); )
  481.        {
  482.        switch(tag->ti_Tag)
  483.            {
  484.            case mt_StrReq_WinTitle:
  485.                WindowTitle = (char *)tag->ti_Data;
  486.                break;
  487.  
  488.            case mt_StrReq_Contents:
  489.                Contents = (char *)tag->ti_Data;
  490.                break;
  491.  
  492.            case mt_StrReq_Ok:
  493.                Ok = (char *)tag->ti_Data;
  494.                break;
  495.  
  496.            case mt_StrReq_Cancel:
  497.                Cancel = (char *)tag->ti_Data;
  498.                break;
  499.  
  500.            case mt_StrReq_Secret:
  501.                Secret = tag->ti_Data;
  502.                break;
  503.  
  504.            case mt_StrReq_NoEmpty:
  505.                NoEmpty = tag->ti_Data;
  506.                break;
  507.  
  508.            case mt_StrReq_GroupTitle:
  509.                GroupTitle = (char *)tag->ti_Data;
  510.                break;
  511.  
  512.            case mt_StrReq_Info:
  513.                Info = (char *)tag->ti_Data;
  514.                break;
  515.  
  516.            case mt_StrReq_StringHelp:
  517.                StringHelp = (char *)tag->ti_Data;
  518.                break;
  519.  
  520.            }
  521.        }
  522.  
  523.  
  524. ///   Create window
  525.  
  526.        Window = WindowObject,
  527.                         MUIA_Window_ID         , ID_MT_STRREQ,
  528. //                        MUIA_Window_ScreenTitle, ScreenTitle,
  529.                         MUIA_Window_Title      , WindowTitle,
  530.                         WindowContents,
  531.                            VGroup,
  532.  
  533.                            Child, GR_Group = VGroup,
  534.                                   GroupFrameT( GroupTitle ),
  535.                                   Child, ST_String = mt_String( Contents, buf_len, NULL, StringHelp ),
  536.                                   End,
  537.  
  538.                            Child, HGroup,
  539.                                   MUIA_Group_SameSize, TRUE,
  540.                                   Child, BT_Ok     = mt_Button( Ok, NULL ),
  541.                                   Child, BT_Cancel = mt_Button( Cancel, NULL ),
  542.                                   End,
  543.  
  544.                            End,
  545.                       End;
  546.  
  547.  
  548.        if( !Window )
  549.            return( FALSE );
  550.  
  551.  
  552.        if( Info )
  553.            {
  554.            Object *FT_Info = FloattextObject,
  555.                                TextFrame, TextBack,
  556.                                MUIA_Floattext_Text, Info,
  557.                                End;
  558.  
  559.            if( FT_Info )
  560.                {
  561.                if (DoMethod( GR_Group, MUIM_Group_InitChange ))
  562.                    {
  563.                    DoMethod( GR_Group, OM_REMMEMBER, ST_String );
  564.  
  565.                    DoMethod( GR_Group, OM_ADDMEMBER, FT_Info );
  566.                    DoMethod( GR_Group, OM_ADDMEMBER, ST_String );
  567.  
  568.                    DoMethod( GR_Group, MUIM_Group_ExitChange );
  569.                    }
  570.                }
  571.  
  572.            }
  573. //|
  574.  
  575.  
  576.     mt_Sleep( TRUE );
  577.  
  578.  
  579.     // notification
  580.     DoMethod(Window   , MUIM_Notify, MUIA_Window_CloseRequest, TRUE ,MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_CANCEL);
  581.     DoMethod(BT_Ok    , MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_OK);
  582.     DoMethod(BT_Cancel, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_CANCEL);
  583.  
  584.  
  585.     // setting up...
  586.     if( WindowTitle )
  587.        set( Window, MUIA_Window_Title, WindowTitle );
  588.  
  589.     if( Contents )
  590.         setstring( ST_String, Contents );
  591.  
  592.     set( Window, MUIA_Window_ActiveObject, ST_String );
  593.  
  594. /*
  595.     if( NoEmpty )
  596.        set( BT_Ok, MUIA_Disabled,  (*(char *)getstring( ST_String ) == 0 ) );
  597. */
  598.  
  599.  
  600.     mt_WinAttach( app, Window );
  601.  
  602.  
  603.     // let's go
  604.  
  605.     {
  606.     char  running = TRUE;
  607.     ULONG signal  = 0;
  608.  
  609.  
  610.     if(  mt_WinOpen( Window ) )
  611.        {
  612.        while(running)
  613.           {
  614.           switch (DoMethod(app, MUIM_Application_Input, &signal))
  615.             {
  616.             case ID_OK:
  617.                {
  618.                char *buf = getstring( ST_String );
  619.  
  620.                if( NoEmpty && buf[0] == 0 )
  621.                    {
  622.                    DisplayBeep(0);
  623.                    set( Window, MUIA_Window_ActiveObject, ST_String );
  624.                    break;
  625.                    }
  626.  
  627.                strncpy(buffer, buf, buf_len);
  628.                result = TRUE;
  629.                running = FALSE;
  630.                }
  631.                break;
  632.  
  633.             case ID_CANCEL:
  634.                running = FALSE;
  635.                break;
  636.  
  637.             }
  638.           if(running && signal) Wait(signal);
  639.           }
  640.  
  641.        mt_WinClose( Window );
  642.        }
  643.     else
  644.        {
  645.        DisplayBeep(0);
  646. //       MUI_Request(app, MainWindow, 0, TITLE, MSG_OK, MSG_ERR_WINDOW);
  647.        }
  648.     }
  649.  
  650.  
  651.     mt_WinDetach( app, Window );
  652.  
  653.     mt_Sleep( FALSE );
  654.  
  655.     return(result);
  656.  
  657.  
  658. }
  659. //|
  660. /// mt_GetIntegerA
  661.  
  662. /*
  663. ** Requester dot. wartoôci numerycznych
  664. ** Zwraca BOOL w zaleûnoôci czy uûytkownik
  665. ** wybraî OK czy nie. Wynik umieszczany
  666. ** jest w odpowiednim polu struktury StringRequest
  667. ** w zaleûnoôci od typu reqestera
  668. */
  669.  
  670.  
  671. ULONG SAVEDS ASM mt_GetIntegerA( REG(a0) Object *app,
  672.                                  REG(a1) LONG   *value,
  673.                                  REG(a2) struct TagItem *tagitem)
  674.  
  675. {
  676. Object *Window      = NULL,     /* STRING REQUESTER */
  677.        *GR_Group,
  678.        *ST_String,
  679.        *BT_Ok,
  680.        *BT_Cancel,
  681.  
  682.        *GR_Bound = NULL;
  683.  
  684.  
  685. #define MSG_INTREQ_WINTITLE "Integer request"
  686. #define MSG_INTREQ_TITLE    "Enter value"
  687. #define MSG_INTREQ_OK       "_Ok"
  688. #define MSG_INTREQ_CANCEL   "_Cancel"
  689.  
  690. #define INTREQ_SIZE 30
  691.  
  692. char Contents[ INTREQ_SIZE ] = "";
  693. char *WindowTitle = MSG_INTREQ_WINTITLE;
  694. char *GroupTitle  = MSG_INTREQ_TITLE;
  695. char *Ok          = MSG_INTREQ_OK;
  696. char *Cancel      = MSG_INTREQ_CANCEL;
  697. char *Info        = NULL;
  698. char *StringHelp  = NULL;
  699.  
  700. char MinBound = FALSE;
  701. char MaxBound = FALSE;
  702. LONG MinVal, MaxVal;
  703.  
  704. struct TagItem *tags, *tag;
  705.  
  706. char  result  = FALSE;
  707.  
  708.  
  709.     if( !app )
  710.        return( FALSE );
  711.  
  712.  
  713.     for(tags=tagitem; tag = NextTagItem( &tags ); )
  714.        {
  715.        switch(tag->ti_Tag)
  716.            {
  717.            case mt_IntReq_WinTitle:
  718.                WindowTitle = (char *)tag->ti_Data;
  719.                break;
  720.  
  721.            case mt_IntReq_Value:
  722.                sprintf(Contents, "%ld", (LONG)tag->ti_Data );
  723.                break;
  724.  
  725.            case mt_IntReq_Ok:
  726.                Ok = (char *)tag->ti_Data;
  727.                break;
  728.  
  729.            case mt_IntReq_Cancel:
  730.                Cancel = (char *)tag->ti_Data;
  731.                break;
  732.  
  733.            case mt_IntReq_GroupTitle:
  734.                GroupTitle = (char *)tag->ti_Data;
  735.                break;    
  736.  
  737.            case mt_IntReq_Min:
  738.                MinVal   = (LONG)tag->ti_Data;
  739.                MinBound = TRUE;
  740.                break;
  741.  
  742.            case mt_IntReq_Max:
  743.                MaxVal   = (LONG)tag->ti_Data;
  744.                MaxBound = TRUE;
  745.                break;
  746.  
  747.            case mt_IntReq_Info:
  748.                Info = (char *)tag->ti_Data;
  749.                break;
  750.  
  751.            case mt_IntReq_StringHelp:
  752.                StringHelp = (char *)tag->ti_Data;
  753.                break;
  754.            }
  755.        }
  756.  
  757.  
  758.     // some anti-dummies checks...
  759.  
  760.     if( MinBound && MaxBound )
  761.        if( MinVal > MaxVal )
  762.            {
  763.            LONG tmp = MinVal;
  764.  
  765.            MinVal = MaxVal;
  766.            MaxVal = tmp;
  767.            }
  768.  
  769.  
  770. ///   Create window
  771.         Window = WindowObject,
  772.                         MUIA_Window_ID         , ID_MT_INTREQ,
  773. //                        MUIA_Window_ScreenTitle, ScreenTitle,
  774.                         MUIA_Window_Title      , WindowTitle,
  775.                         WindowContents,
  776.                            VGroup,
  777.  
  778.                            Child, GR_Group = VGroup,
  779.                                   GroupFrameT( GroupTitle ),
  780.                                   Child, ST_String = mt_StringAccept( Contents, INTREQ_SIZE, NULL, "-0123456789", StringHelp ),
  781.                                   End,
  782.  
  783.                            Child, HGroup,
  784.                                   MUIA_Group_SameSize, TRUE,
  785.                                   Child, BT_Ok     = mt_Button( Ok, NULL ),
  786.                                   Child, BT_Cancel = mt_Button( Cancel, NULL ),
  787.                                   End,
  788.  
  789.                            End,
  790.                       End;
  791.  
  792.     if( !Window )
  793.        return(FALSE);
  794.  
  795.  
  796.     if( Info )
  797.            {
  798.            Object *FT_Info = FloattextObject,
  799.                                TextFrame, TextBack,
  800.                                MUIA_Floattext_Text, Info,
  801.                                End;
  802.  
  803.            if( FT_Info )
  804.                {
  805.                if (DoMethod( GR_Group, MUIM_Group_InitChange ))
  806.                    {
  807.                    DoMethod( GR_Group, OM_REMMEMBER, ST_String );
  808.  
  809.                    DoMethod( GR_Group, OM_ADDMEMBER, FT_Info );
  810.                    DoMethod( GR_Group, OM_ADDMEMBER, ST_String );
  811.  
  812.                    DoMethod( GR_Group, MUIM_Group_ExitChange );
  813.                    }
  814.                }
  815.  
  816.            }
  817.  
  818. //|
  819.  
  820.     // any bounds?
  821.  
  822.     if( MinBound || MaxBound )
  823.        {
  824.        GR_Bound = HGroup, MUIA_Group_SameSize, TRUE, End;
  825.  
  826.        if( GR_Bound )
  827.            {
  828.            char tmp[60];
  829.  
  830.            if( MinBound )
  831.                {
  832.                sprintf( tmp, "\033bMin:\033n %ld", MinVal );
  833.                DoMethod( GR_Bound, OM_ADDMEMBER, mt_Text( tmp, "\033c" ) );
  834.                }
  835.  
  836.            if( MaxBound )
  837.                {
  838.                sprintf( tmp, "\033bMax:\033n %ld", MaxVal );
  839.                DoMethod( GR_Bound, OM_ADDMEMBER, mt_Text( tmp, "\033c" ) );
  840.                }
  841.  
  842.            DoMethod( GR_Group, OM_ADDMEMBER, GR_Bound );
  843.            }
  844.        else
  845.            {
  846.            MUI_DisposeObject( Window );
  847.            return( FALSE );
  848.            }
  849.        }
  850.  
  851.     mt_Sleep( TRUE );
  852.  
  853.  
  854.     // notification
  855.     DoMethod(Window   , MUIM_Notify, MUIA_Window_CloseRequest, TRUE ,MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_CANCEL);
  856.     DoMethod(BT_Ok    , MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_OK);
  857.     DoMethod(BT_Cancel, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_CANCEL);
  858.  
  859.  
  860.     // setting up...
  861.     if( WindowTitle )
  862.        set( Window, MUIA_Window_Title, WindowTitle );
  863.  
  864.     if( Contents )
  865.         setstring( ST_String, Contents );
  866.  
  867.     set( Window, MUIA_Window_ActiveObject, ST_String );
  868.  
  869. /*
  870.     if( NoEmpty )
  871.        set( BT_Ok, MUIA_Disabled,  (*(char *)getstring( ST_String ) == 0 ) );
  872. */
  873.  
  874.  
  875.     mt_WinAttach( app, Window );
  876.  
  877.  
  878.     // let's go
  879.  
  880.     {
  881.     char  running = TRUE;
  882.     ULONG signal  = 0;
  883.  
  884.  
  885.     if(  mt_WinOpen( Window ) )
  886.        {
  887.        while(running)
  888.           {
  889.           switch (DoMethod(app, MUIM_Application_Input, &signal))
  890.             {
  891.             case ID_OK:
  892.                {
  893.                char *buf = getstring( ST_String );
  894.                LONG val  = getnumstring( ST_String );
  895.  
  896.                if( buf[0] == 0 )
  897.                    {
  898.                    result = running = FALSE;
  899.                    break;
  900.                    }
  901.  
  902.  
  903.                if( MinBound )
  904.                    {
  905.                    if( val < MinVal )
  906.                        {
  907.                        DisplayBeep(0);
  908.                        set( Window, MUIA_Window_ActiveObject, ST_String );
  909.                        break;
  910.                        }
  911.                    }
  912.  
  913.                if( MaxBound )
  914.                    {
  915.                    if( val > MaxVal )
  916.                        {
  917.                        DisplayBeep(0);
  918.                        set( Window, MUIA_Window_ActiveObject, ST_String );
  919.                        break;
  920.                        }
  921.                    }
  922.  
  923.                *value = val;
  924.                result = TRUE;
  925.                running = FALSE;
  926.                }
  927.                break;
  928.  
  929.             case ID_CANCEL:
  930.                running = FALSE;
  931.                break;
  932.  
  933.             }
  934.           if(running && signal) Wait(signal);
  935.           }
  936.  
  937.        mt_WinClose( Window );
  938.        }
  939.     else
  940.        {
  941.        DisplayBeep(0);
  942. //       MUI_Request(app, MainWindow, 0, TITLE, MSG_OK, MSG_ERR_WINDOW);
  943.        }
  944.     }
  945.  
  946.  
  947.     mt_WinDetach( app, Window );
  948.  
  949.     mt_Sleep( FALSE );
  950.  
  951.     return(result);
  952.  
  953.  
  954. }
  955. //|
  956.  
  957.  
  958. /*
  959. /// tmp
  960. /*
  961. Object *TextButton2(char *str, char *str2)
  962. {
  963.         Object *obj = MUI_NewObject(MUIC_Text,
  964.                                 ButtonFrame,
  965.                                 MUIA_Text_PreParse, "\33c",
  966.                                 MUIA_Text_Contents, str,
  967.                                 MUIA_CycleChain   , TRUE,
  968.                                 MUIA_InputMode    , MUIV_InputMode_RelVerify,
  969.                                 MUIA_Background   , MUII_ButtonBack,
  970.                                 MUIA_Text_HiChar  , (ULONG)( str2 )[0],
  971.                                 MUIA_ControlChar  , (ULONG)( str2 )[0],
  972.                                 TAG_DONE
  973.                                 );
  974.         return(obj);
  975. }
  976. */
  977. /*
  978. Object *SizedButton(char *str)
  979. {
  980.     Object *obj = VGroup,
  981.                   ButtonFrame,
  982.                   MUIA_ControlChar  , mt_ParseHotkey(str),
  983.                   MUIA_Background   , MUII_ButtonBack,
  984.                   MUIA_InputMode    , MUIV_InputMode_RelVerify,
  985.                   MUIA_CycleChain   , TRUE,
  986.                   Child, HVSpace,
  987.                   Child, HGroup,
  988.                          Child, HVSpace,
  989.                          Child, MakeLabel2(str),
  990.                          Child, HVSpace,
  991.                          End,
  992.  
  993.                   Child, HVSpace,
  994.                   End;
  995.  
  996.     return(obj);
  997. }
  998. */
  999. //|
  1000. */
  1001.  
  1002.